#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstring>

// void *fun(void*args)
// {

// }

// int main()
// {
//     pthread_t tid;
//     std::cout<<tid<<"\n";
//     pthread_create(&tid,nullptr,fun,nullptr);
//     std::cout<<tid<<"\n";
//     return 0;
// }

// // 新线程
// void* fun(void* args)
// {
//     while (true)
//     {
//         std::cout << "新线程正在运行" << std::endl;
//         sleep(1);
//     }
// }

// // 主线程
// int main()
// {
//     // 记录线程 id
//     pthread_t tid;

//     // 创建新线程，并让新线程去执行 fun 函数
//     if(pthread_create(&tid, nullptr, fun, nullptr)!=0)
//     {
//         perror("pthread_create:");
//         exit(-1);
//     }

//     // 主线程继续执行自己后续的代码
//     while (true)
//     {
//         std::cout << "主线程正在运行" << std::endl;
//         sleep(1);
//     }

//     return 0;
// }

// #include <unistd.h>
// #include <iostream>
// #include <pthread.h>
// #include <string>

// struct Data
// {
//     Data(const std::string &name): _name(name)
//     {}
//     std::string GetName()
//     {
//         return _name;
//     }
//     std::string _name;
// };

// void *fun(void *args)
// {
//     Data *td = static_cast<Data *>(args);

//     while (true)
//     {
//         std::cout << "新线程 " << td->GetName() << " 正在运行" << std::endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     Data *d = new Data("thread 1");

//     // 创建新线程，将 d 对象作为 fun 函数的参数
//     pthread_t tid;
//     pthread_create(&tid, nullptr, fun, d);

//     while (true)
//     {
//         std::cout << "主线程正在运行" << std::endl;
//         sleep(1);
//     }

//     return 0;
// }

// #include <pthread.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include<iostream>

// void* thread_function(void* arg) {
//     // 线程的工作内容
//     printf("Thread is running\n");

//     // 假设我们在这里完成了工作，现在准备退出
//     // 返回一个指向整数的指针，表示退出状态
//     int* status = (int*)malloc(sizeof(int));
//     *status = 0; // 假设 0 表示成功  当然也可以传入其他类型指针，强转就行了
//     pthread_exit((void*)status);

//     // 注意：以下代码不会被执行，因为线程已经通过 pthread_exit 退出了
//     printf("This line will not be executed\n");

//     // 如果需要释放 status 指向的内存，应该在 pthread_exit 调用之前完成
//     // 但是pthread_join应该负责处理这个内存。
//     // free(status);
// }
// int main() {
//     pthread_t thread;
//     int* thread_return;

//     // 创建线程
//     pthread_create(&thread, NULL, thread_function, NULL);

//     // 等待线程结束，并获取其返回值
//     pthread_join(thread, (void**)&thread_return);

//     // 处理线程的返回值
//     if (thread_return != NULL) {
//         printf("Thread returned: %d\n", *thread_return);
//         free(thread_return); // 释放之前线程函数分配的内存
//     }

//     return 0;
// }

// #include <string>
// #include <unistd.h>
// #include <iostream>
// #include <pthread.h>

// void* thread_run(void* args)
// {
//     std::string thread_name = static_cast<const char*>(args);

//     while (true)
//     {
//         std::cout << thread_name << " 正在运行" << std::endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, thread_run, (void*)"thread -1");
//     std::cout << "主线程正在运行" << std::endl;
//     sleep(5);
//     pthread_cancel(tid);    // 主线程终止新线程
//     std::cout << "新线程已被终止" << std::endl;

//     return 0;
// }

// // 线程运行的函数
// void* threadFunction(void* arg) {
//     // 假设我们不需要传递任何参数给线程函数
//     // 这里的arg参数只是为了满足pthread_create的签名
//     (void)arg;

//     // 动态分配一个字符串
//     char* message = strdup("Hello from thread!");
//     if (message == NULL) {
//         // 如果内存分配失败，则线程返回NULL
//         return NULL;
//     }

//     // 线程返回字符串的地址
//     return (void*)message;
// }

// int main() {
//     pthread_t threadId;
//     void* threadResult;
//     char* message;

//     // 创建一个新线程
//     if (pthread_create(&threadId, NULL, threadFunction, NULL) != 0) {
//         printf("Error: unable to create thread\n");
//         return 1;
//     }

//     // 等待线程结束并获取其返回值
//     if (pthread_join(threadId, &threadResult) != 0) {
//         printf("Error: unable to join thread\n");
//         return 1;
//     }

//     // 将void*类型的返回值转换为char*类型
//     message = (char*)threadResult;

//     // 打印字符串
//     printf("%s\n", message);

//     // 释放字符串以避免内存泄漏
//     free(message);

//     return 0;
// }

// void* thread_function(void* arg) {
//     // 线程执行的代码
//     printf("Thread is running\n");
//     return nullptr;
// }

// int main() {
//     pthread_t thread_id;
//     int result;

//     // 创建线程
//     result = pthread_create(&thread_id, NULL, thread_function, NULL);
//     if (result != 0) {
//         perror("Failed to create thread");
//         exit(EXIT_FAILURE);
//     }
//     // 将线程设置为分离状态
//     result = pthread_detach(thread_id);
//     if (result != 0) {
//         perror("Failed to detach thread");
//         exit(EXIT_FAILURE);
//     }
//     sleep(3);
//     int n=pthread_join(thread_id,nullptr);
//     std::cout<<"pthread_join return val : "<<n<<std::endl;
//     return 0;
// }

#include <string>
#include <vector>
#include <unistd.h>
#include <iostream>
#include <pthread.h>

struct Data
{
    Data(const std::string &name)
        : _name(name)
    {}
    std::string thread_name()
    {
        return _name;
    }
    std::string _name;
};

void *thread_run(void *args)
{
    Data *td = static_cast<Data *>(args);

    while (true)
    {
        std::cout << "新线程 " << td->thread_name() << " 正在运行" << std::endl;
        sleep(1);
    }
    return nullptr;
}

const int gnum = 5; // 5 个线程

int main()
{
    // 存储创建的所有线程的线程 ID
    std::vector<pthread_t> tids(gnum);

    // 创建 5 个线程并给每个线程传递一个 Data 对象
    for (size_t i = 0; i < gnum; i++)
    {
        std::string name = "thread " + std::to_string(i + 1);
        Data *td = new Data(name);
        pthread_create(&tids[i], nullptr, thread_run, td);
    }

    while (true)
    {
        std::cout << "主线程正在运行" << std::endl;
        sleep(1);
    }

    return 0;
}
